from fastapi import APIRouter, HTTPException, Query
from fastapi.responses import StreamingResponse, JSONResponse
from typing import Optional

from app.utils.fake_data import FakeDataGenerator
from app.models.schemas import UserRequest, DataResponse
from app.models.coze_schemas import CozeRequest, CozeResponse, CozeStreamResponse
from app.services.data_generator import DataGenerator
from app.services.coze_service import CozeService
from app.utils.prompt_analyzer import PromptAnalyzer
from app.core.coze_config import coze_settings

router = APIRouter()
data_generator = DataGenerator()
prompt_analyzer = PromptAnalyzer()
coze_service = CozeService()
fake_data_generator = FakeDataGenerator()

@router.get("/fake/data")
def generate_fake_data(
    count: Optional[int] = Query(1, description="生成数据的条数", ge=1, le=100)
) -> JSONResponse:
    """生成假数据，包括：
    - 111开头的手机号
    - UUID
    - 时间戳（秒）
    - 时间戳（毫秒）
    - 格式化时间
    
    参数：
    - count: 生成数据的条数，默认为1，最小1条，最大100条
    
    示例响应：
    ```json
    {
        "data": [
            {
                "phone": "11112345678",
                "uuid": "550e8400-e29b-41d4-a716-446655440000",
                "timestamp_seconds": 1616161616,
                "timestamp_milliseconds": 1616161616000,
                "formatted_time": "2021-03-19 12:13:36"
            }
        ]
    }
    ```
    """
    data = fake_data_generator.generate_multiple_data(count)
    return JSONResponse(content={"data": data})

@router.get("/fake/phone")
def generate_fake_phone(
    count: Optional[int] = Query(1, description="生成手机号的条数", ge=1, le=100)
) -> JSONResponse:
    """生成111开头的手机号
    
    参数：
    - count: 生成手机号的条数，默认为1，最小1条，最大100条
    
    示例响应：
    ```json
    {
        "data": ["11112345678"]
    }
    ```
    """
    phones = [fake_data_generator.generate_phone() for _ in range(count)]
    return JSONResponse(content={"data": phones})

@router.get("/fake/uuid")
def generate_fake_uuid(
    count: Optional[int] = Query(1, description="生成UUID的条数", ge=1, le=100)
) -> JSONResponse:
    """生成UUID
    
    参数：
    - count: 生成UUID的条数，默认为1，最小1条，最大100条
    
    示例响应：
    ```json
    {
        "data": ["550e8400-e29b-41d4-a716-446655440000"]
    }
    ```
    """
    uuids = [fake_data_generator.generate_uuid() for _ in range(count)]
    return JSONResponse(content={"data": uuids})

@router.get("/fake/timestamp")
def generate_fake_timestamp(
    count: Optional[int] = Query(1, description="生成时间戳的条数", ge=1, le=100)
) -> JSONResponse:
    """生成时间戳（包括秒、毫秒和格式化时间）
    
    参数：
    - count: 生成时间戳的条数，默认为1，最小1条，最大100条
    
    示例响应：
    ```json
    {
        "data": [
            {
                "timestamp_seconds": 1616161616,
                "timestamp_milliseconds": 1616161616000,
                "formatted_time": "2021-03-19 12:13:36"
            }
        ]
    }
    ```
    """
    timestamps = [fake_data_generator.generate_timestamp() for _ in range(count)]
    return JSONResponse(content={"data": timestamps})

@router.post("/generate_data", response_model=DataResponse)
async def generate_data(request: UserRequest):
    """
    根据prompt生成测试数据
    """
    try:
        # 从prompt中分析出数据类型和数量
        data_type, count = prompt_analyzer.analyze_prompt(request.prompt)
        
        # 如果是查询支持的数据类型
        if data_type == 'show_types':
            type_descriptions = {
                'person': '生成详细的个人信息数据，包含姓名、地址、电话、邮箱等',
                'article': '生成文章相关数据，包含标题、内容、作者、发布日期等',
                'company': '生成公司相关数据，包含公司名称、地址、类型、联系方式等',
                'product': '生成产品相关数据，包含名称、描述、价格、库存等',
                'order': '生成订单相关数据，包含订单号、客户、金额、状态等',
                'review': '生成用户评论数据，包含用户名、评分、评论内容、日期等',
                'bank_account': '生成银行账户相关数据，包含持有人、账号、银行、余额等',
                'education': '生成教育经历相关数据，包含学生姓名、学校、专业、时间等',
                'social_media': '生成社交媒体账号相关数据，包含用户名、简介、粉丝数等',
                'phone': '生成111开头的手机号',
                'uuid': '生成UUID',
                'timestamp': '生成时间戳数据，包含秒、毫秒和格式化时间'
            }
            return {
                "status": "success",
                "message": "当前支持以下数据类型",
                "data": [{
                    "type": k,
                    "description": v
                } for k, v in type_descriptions.items()],
                "prompt": request.prompt,
                "inferred_type": data_type,
                "count": 0
            }
        
        # 根据数据类型生成不同的数据
        if data_type == 'phone':
            test_data = [{'value': fake_data_generator.generate_phone()} for _ in range(count)]
        elif data_type == 'uuid':
            test_data = [{'value': fake_data_generator.generate_uuid()} for _ in range(count)]
        elif data_type == 'timestamp':
            test_data = [{'data': fake_data_generator.generate_timestamp()} for _ in range(count)]
        else:
            # 使用原有的数据生成逻辑
            test_data = data_generator.generate_data(
                data_type=data_type,
                count=count
            )
        
        return {
            "status": "success",
            "message": "数据生成成功",
            "data": test_data,
            "prompt": request.prompt,
            "inferred_type": data_type,
            "count": count
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

from fastapi.openapi.models import Response
from fastapi import responses

@router.post(
    "/chat",
    responses={
        200: {
            "description": "流式或非流式响应",
            "content": {
                "text/event-stream": {
                    "schema": {
                        "type": "string",
                        "example": "event: message\ndata: {\"code\": 0, \"data\": {\"text\": \"回复内容\"}}\n\n"
                    }
                },
                "application/json": {
                    "schema": {
                        "type": "object",
                        "properties": {
                            "code": {"type": "integer"},
                            "data": {"type": "object"},
                            "msg": {"type": "string"}
                        }
                    }
                }
            }
        }
    }
)
async def chat_with_coze(request: CozeRequest):
    """
    与 Coze API 进行对话

    请求示例:
    ```json
    {
        "content": "你好"
    }
    ```

    响应格式取决于配置文件中的 STREAM 设置:

    1. 当 STREAM=True 时（流式响应）:
       - Content-Type: text/event-stream
       - 每条消息格式:
         ```
         event: message
         data: {"code": 0, "data": {"text": "回复内容"}}

         ```
       - 错误消息格式:
         ```
         event: error
         data: {"code": 错误码, "msg": "错误信息"}

         ```
       - 结束消息:
         ```
         event: done
         data: {"status": "completed"}

         ```

    2. 当 STREAM=False 时（普通响应）:
       - Content-Type: application/json
       - 响应格式:
         ```json
         {
           "code": 0,
           "data": {
             "text": "回复内容"
           }
         }
         ```

    注意：
    1. 响应类型由配置文件中的 STREAM 参数控制
    2. 使用流式响应时，可以通过以下方式测试：
       - 使用调试页面：[打开调试页面](/debug/debug.html)
       - 使用 curl 命令：
         ```bash
         curl -N -X POST \
           -H "Content-Type: application/json" \
           -d '{"content": "你好"}' \
           http://localhost:8010/chat
         ```
    3. 调试页面功能：
       - 支持发送消息并实时显示流式响应
       - 显示完整的响应内容
       - 支持清除输出
       - 错误信息高亮显示
    """
    try:
        async def stream_generator():
            async for chunk in coze_service.send_message_stream(request.content):
                yield chunk

        if coze_settings.STREAM:
            response = StreamingResponse(
                content=stream_generator(),
                media_type="text/event-stream"
            )
            response.headers["Cache-Control"] = "no-cache"
            response.headers["Connection"] = "keep-alive"
            response.headers["X-Accel-Buffering"] = "no"
            return response
        else:
            result = await coze_service.send_message_sync(request.content)
            return result
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))
